package com.atguigu.a_principle.p2interface.v1;

/**
 * 接口隔离原则
 * 客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上
 */
public class Segregation {
    /**
     *  类 A 通过接口 Interface1 依赖类 B，类 C 通过接口 Interface1 依赖类 D，如果接口 Interface1 对于类 A 和类 C
     * 来说不是最小接口，那么类 B 和类 D 必须去实现他们不需要的方法。
     *  按隔离原则应当这样处理：
     * 将接口 Interface1 拆分为独立的几个接口(这里我们拆分成 3 个接口)，类 A 和类 C 分别与他们需要的接口建立
     * 依赖关系。也就是采用接口隔离原则
     */
    public static void main(String[] args) {
        A a = new A();
        C c = new C();
        a.dependency1(new B());
        a.dependency2(new B());
        a.dependency3(new B());

        c.dependency1(new D());
        c.dependency4(new D());
        c.dependency5(new D());

    }
/**
 *  类 A 通过接口 Interface1 依赖类 B，类 C 通过接口 Interface1 依赖类 D，如果接口 Interface1 对于类 A 和类 C
    来说不是最小接口，那么类 B 和类 D 必须去实现他们不需要的方法
    将接口 Interface1 拆分为独立的几个接口，类 A 和类 C 分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则
    接口 Interface1 中出现的方法，根据实际情况拆分为三个接口
 */

}

interface interface1 {
    void opreation1();
    void opreation2();
    void opreation3();
    void opreation4();
    void opreation5();
}
// 类B 实现了接口interface1，
class B implements interface1 {
    @Override
    public void opreation1() {
        System.out.println("B 实现了operation 1");
    }

    @Override
    public void opreation2() {
        System.out.println("B 实现了operation 2");
    }

    @Override
    public void opreation3() {
        System.out.println("B 实现了operation 3");
    }

    @Override
    public void opreation4() {
        System.out.println("B 实现了operation 4");
    }

    @Override
    public void opreation5() {
        System.out.println("B 实现了operation 5");
    }
}

//类D实现了接口interface1
class D implements interface1 {
    @Override
    public void opreation1() {
        System.out.println("D 实现了operation 1");
    }

    @Override
    public void opreation2() {
        System.out.println("D 实现了operation 2");
    }

    @Override
    public void opreation3() {
        System.out.println("D 实现了operation 3");
    }

    @Override
    public void opreation4() {
        System.out.println("D 实现了operation 4");
    }

    @Override
    public void opreation5() {
        System.out.println("D 实现了operation 5");
    }
}

//A 类通过接口 Interface1 依赖(使用) B 类，但是只会用到 1,2,3 方法
class A{
    public void dependency1(interface1 i) {
        i.opreation1();
    }

    public void dependency2(interface1 i) {
        i.opreation2();
    }

    public void dependency3(interface1 i) {
        i.opreation3();
    }
}

//C 类通过接口 Interface1 依赖(使用) D 类，但是只会用到 1,4,5 方法
class C{
    public void dependency1(interface1 i) {
        i.opreation1();
    }

    public void dependency4(interface1 i) {
        i.opreation4();
    }

    public void dependency5(interface1 i) {
        i.opreation5();
    }
}